#include "global_variable.h"
#include "debug.h"


struct globalVariable_s
{
    bool     boolValue[GV_BOOL_QTY];
    uint8_t  uint8Value[GV_UINT8_QTY];
    int8_t   int8Value[GV_INT8_QTY];
    uint16_t uint16Value[GV_UINT16_QTY];
    int16_t  int16Value[GV_INT16_QTY];
    uint32_t uint32Value[GV_UINT32_QTY];
    int32_t  int32Value[GV_INT32_QTY];
    float    floatValue[GV_FLOAT_QTY];
    double   doubleValue[GV_DOUBLE_QTY];
};


static struct globalVariable_s globalVariable = {0};


/**
 * @brief 获取Bool全局变量
 * @param idx    - 索引 参考<gvBoolIdx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetBool(gvBoolIdx_t idx, bool *pValue)
{
    if(idx >= GV_BOOL_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_BOOL_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.boolValue[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Uint8全局变量
 * @param idx    - 索引 参考<gvUint8Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetUint8(gvUint8Idx_t idx, uint8_t *pValue)
{
    if(idx >= GV_UINT8_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT8_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.uint8Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Int8全局变量
 * @param idx    - 索引 参考<gvInt8Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetInt8(gvInt8Idx_t idx, int8_t *pValue)
{
    if(idx >= GV_INT8_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT8_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.int8Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Uint16全局变量
 * @param idx    - 索引 参考<gvUint16Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetUint16(gvUint16Idx_t idx, uint16_t *pValue)
{
    if(idx >= GV_UINT16_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT16_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.uint16Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Int16全局变量
 * @param idx    - 索引 参考<gvInt16Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetInt16(gvInt16Idx_t idx, int16_t *pValue)
{
    if(idx >= GV_INT16_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT16_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.int16Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Uint32全局变量
 * @param idx    - 索引 参考<gvUint32Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetUint32(gvUint32Idx_t idx, uint32_t *pValue)
{
    if(idx >= GV_UINT32_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT32_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.uint32Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Int32全局变量
 * @param idx    - 索引 参考<gvInt32Idx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetInt32(gvInt32Idx_t idx, int32_t *pValue)
{
    if(idx >= GV_INT32_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT32_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.int32Value[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Float全局变量
 * @param idx    - 索引 参考<gvFloatIdx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetFloat(gvFloatIdx_t idx, float *pValue)
{
    if(idx >= GV_FLOAT_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_FLOAT_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.floatValue[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 获取Double全局变量
 * @param idx    - 索引 参考<gvDoubleIdx_t>
 * @param pValue - 存放获取值的变量指针
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_GetDouble(gvDoubleIdx_t idx, double *pValue)
{
    if(idx >= GV_DOUBLE_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_DOUBLE_QTY);
        return -GV_ERR_PARAM;
    }

    *pValue = globalVariable.doubleValue[idx];
    return GV_ERR_NONE;
}


/**
 * @brief 设置Bool全局变量
 * @param idx   - 索引 参考<gvBoolIdx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetBool(gvBoolIdx_t idx, bool value)
{
    if(idx >= GV_BOOL_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_BOOL_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.boolValue[idx] = (bool)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Uint8全局变量
 * @param idx   - 索引 参考<gvUint8Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetUint8(gvUint8Idx_t idx, uint8_t value)
{
    if(idx >= GV_UINT8_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT8_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.uint8Value[idx] = (uint8_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Int8全局变量
 * @param idx   - 索引 参考<gvInt8Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetInt8(gvInt8Idx_t idx, int8_t value)
{
    if(idx >= GV_INT8_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT8_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.int8Value[idx] = (int8_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Uint16全局变量
 * @param idx   - 索引 参考<gvUint16Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetUint16(gvUint16Idx_t idx, uint16_t value)
{
    if(idx >= GV_UINT16_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT16_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.uint16Value[idx] = (uint16_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Int16全局变量
 * @param idx   - 索引 参考<gvInt16Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetInt16(gvInt16Idx_t idx, int16_t value)
{
    if(idx >= GV_INT16_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT16_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.int16Value[idx] = (int16_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Uint32全局变量
 * @param idx   - 索引 参考<gvUint32Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetUint32(gvUint32Idx_t idx, uint32_t value)
{
    if(idx >= GV_UINT32_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_UINT32_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.uint32Value[idx] = (uint32_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Int32全局变量
 * @param idx   - 索引 参考<gvInt32Idx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetInt32(gvInt32Idx_t idx, int32_t value)
{
    if(idx >= GV_INT32_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_INT32_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.int32Value[idx] = (int32_t)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Float全局变量
 * @param idx   - 索引 参考<gvFloatIdx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetFloat(gvFloatIdx_t idx, float value)
{
    if(idx >= GV_FLOAT_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_FLOAT_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.floatValue[idx] = (float)value;
    return GV_ERR_NONE;
}


/**
 * @brief 设置Double全局变量
 * @param idx   - 索引 参考<gvDoubleIdx_t>
 * @param value - 设置值
 * @return 参考<gvErr_t>
 */
gvErr_t GlobalVariable_SetDouble(gvDoubleIdx_t idx, double value)
{
    if(idx >= GV_DOUBLE_QTY)
    {
        PRINT_WARN("Parameter error[%d >= %d]", idx, GV_DOUBLE_QTY);
        return -GV_ERR_PARAM;
    }

    globalVariable.doubleValue[idx] = (double)value;
    return GV_ERR_NONE;
}

